home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / glass / glass.lha / GLASS / contsens / handcom.c < prev    next >
Text File  |  1991-01-31  |  4KB  |  185 lines
  1.  
  2. /*   Copyright (C) 1990 Riet Oolman
  3.  
  4. This file is part of GLASS.
  5.  
  6. GLASS is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GLASS is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GLASS; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. int fscan_bool( f, p )
  21.  FILE *f;
  22.  bool *p;
  23. { char word[WORDBUFSIZE];
  24.     *p = boolNIL;
  25.     if( fscancons( f, word ) ) return( 1 );
  26.     if( strcmp( word, "True" ) == 0 )
  27.     { *p = true; }
  28.     else if( strcmp( word, "False" ) == 0 )
  29.          { *p = false; }
  30.          else 
  31.          {(void) sprintf( tmerrmsg, tm_badcons, "bool", word );
  32.           return( 1 ); }
  33.     return(0);
  34. }
  35.  
  36. int fscan_symbol(f,s)
  37. FILE *f;
  38. symbol *s;
  39. { char *st;
  40.   long l;
  41.  
  42.   *s = symbolNIL;
  43.   if (fscan_string(f,&st))
  44.   {return(1);}
  45.   else
  46.   {
  47.     l = 0; while (st[l] != '\0') {l++;};
  48.      *s = Buildsymbol(st,l);
  49.      return(0);
  50.   }
  51. }
  52.  
  53. int fscan_symbol_list( f, p )
  54.  FILE *f;
  55.  symbol_list *p;
  56. {
  57.     int n;
  58.     register int c;
  59.     symbol new;
  60.     register short int err = 0;
  61.  
  62.     *p = symbolNIL;
  63.     n = fscanopenbrac( f );
  64.     if( tmfneedc( f, '[' ) ) return( 1 );
  65.     if( fscanspace( f ) ) return( 1 );
  66.     c = getc( f );
  67.     if( c == EOF ){
  68.         (void) strcpy( tmerrmsg, tm_badeof );
  69.         return( 1 );
  70.     }
  71.     if( c == ']' ) return( 0 );
  72.     ungetc( c, f );
  73.     while( 1 ){
  74.         err = fscan_symbol( f, &new );
  75.         *p = app_symbol_list( *p, new );
  76.         if(err) return( 1 );
  77.         if( fscanspace( f ) ) return( 1 );
  78.         c = getc( f );
  79.         if( c == EOF ){
  80.             (void) strcpy( tmerrmsg, tm_badeof );
  81.             return( 1 );
  82.         }
  83.         if( c != ',' ){
  84.             ungetc( c, f );
  85.             break;
  86.         }
  87.     }
  88.     if( tmfneedc( f, ']' ) ) return( 1 );
  89.     return( fscanclosebrac( f, n ) );
  90. }
  91.  
  92. int fscan_emp(f,p)
  93. FILE *f;
  94. emp *p;
  95. { *p = empNIL;
  96.   *p = (emp)malloc(sizeof(typcrec));
  97.   return(0);
  98. }
  99.  
  100. void print_bool(b)
  101. bool b;
  102. {
  103.   if (b) {printword("True");} else {printword("False");};
  104. }
  105.  
  106. void print_symbol(s)
  107. symbol s;
  108. {
  109.   s->body[s->length]='\0'; /* just to be sure */
  110.   print_string(s->body);
  111. }
  112.  
  113. /* Print list of elements of type 'symbol'
  114.  * using print optimization routines.
  115.  */
  116. void print_symbol_list( l )
  117.  symbol_list l;
  118. {
  119.     openlist();
  120.     while( l!=symbolNIL ){
  121.     print_symbol( l );
  122.     l=l->next;
  123.     }
  124.     closelist();
  125. }
  126.  
  127. symbol Copysymbol(s)
  128. symbol s;
  129. {
  130.   symbol result;
  131.  
  132.   result = (symbol )Malloc(sizeof(stringcell));
  133.   result->next = NULL;
  134.   result->length = s->length;
  135.   memcpy(result->body, s->body, s->length);
  136.   return result;
  137. }  /* Copysymbol */
  138.  
  139. symbol Buildsymbol(s, l)
  140. Char *s;
  141. long l;
  142. {
  143.   symbol result;
  144.  
  145.   if (l>wordlength) 
  146.   {fprintf(stderr, "%s is too long for a symbol", s); return;}
  147.   result = (symbol )Malloc(sizeof(stringcell));
  148.   memcpy(result->body, s,l);
  149.   result->length = l;
  150.   result->next = NULL;
  151.   return result;
  152. }
  153.  
  154.  
  155. Void Writesymbol(f, s)
  156. FILE *f;
  157. symbol s;
  158. { if (s!=NULL)
  159.   { s->body[s->length] = '\0';
  160.     fprintf(f,s->body);
  161.   }
  162. }
  163.  
  164. boolean Equalsymbol(s1, s2)
  165. symbol s1, s2;
  166. { s1->body[s1->length] = '\0';
  167.   s2->body[s2->length] = '\0';
  168.   return (cmp_string(s1->body,s2->body)==0);
  169. }  /* Equalsymbol */
  170.  
  171. /* append list of symbol 'b' after list of symbol 'a' */
  172. static symbol app_symbol_list( a, b )
  173.  symbol_list a;
  174.  symbol b;
  175. {
  176.     register symbol tl;
  177.  
  178.     if( a == symbolNIL ) return( b );
  179.     tl = a;
  180.     while( tl->next != symbolNIL ) tl = tl->next;
  181.     tl->next = b;
  182.     return( a );
  183. }
  184.  
  185.